#include "jsonbean.h"
#include <stdio.h>
#include <malloc.h>
#include <string.h>
#include "cjson/cJSON.h"


#if 0
//判断是否为array
static bool isJsonArray(cJSON *pJson)
{
    bool bArray = false;
    if(pJson) {
        bArray = (pJson->type & 0xFF) == cJSON_Array;
    }

    return bArray;
}
#endif

/************************************************
 * 功能：构造函数
 * 输入参数：
 *      type：Data -- 普通类型，Array -- JSON数组类型
 * ***********************************************/
JsonBean::JsonBean(JsonBean::Type eType)
{
    m_strJsonData.clear();
    m_pJson = nullptr;
    m_bOk = true;

    if(eType == Array)
    {
        m_pJson = cJSON_CreateArray();
    }
    else
    {
        m_pJson = cJSON_CreateObject();
    }
}

/************************************************
 * 功能：构造函数
 * 输入参数：
 *      strJsonData：JSON数据
 * ***********************************************/
JsonBean::JsonBean(const std::string &strJsonData)
{
    m_strJsonData.clear();
    m_pJson = nullptr;
    m_bOk = false;

    m_strJsonData = strJsonData;
    m_pJson = cJSON_Parse(m_strJsonData.c_str());
    m_bOk = m_pJson ? true : false;
}

/************************************************
 * 功能：拷贝构造函数
 * 输入参数：
 *      objOther：JSON对象
 * ***********************************************/
JsonBean::JsonBean(const JsonBean &objOther)
{
    m_strJsonData = objOther.m_strJsonData;
    m_bOk = objOther.m_bOk;

    if(objOther.m_pJson)
    {
        m_pJson = cJSON_Duplicate(objOther.m_pJson, 1);
    }
    else
    {
        m_pJson = nullptr;
    }
}

/************************************************
 * 功能：赋值构造函数
 * 输入参数：
 *      objOther：JSON对象
 * 返回值：
 *      JsonBean：新的JSON对象
 * ***********************************************/
JsonBean& JsonBean::operator=(const JsonBean &objOther)
{
    if(this == &objOther)
    {
        return *this;
    }

    m_strJsonData = objOther.m_strJsonData;
    m_bOk = objOther.m_bOk;

    if(m_pJson)
    {
        cJSON_Delete(m_pJson);
    }

    if(objOther.m_pJson)
    {
        m_pJson = cJSON_Duplicate(objOther.m_pJson, 1);
    }
    else
    {
        m_pJson = nullptr;
    }

    //返回本对象的引用
    return *this;
}

/************************************************
 * 功能：析构函数
 * ***********************************************/
JsonBean::~JsonBean()
{
    m_strJsonData.clear();

    if(m_pJson)
    {
        cJSON_Delete(m_pJson);
        m_pJson = nullptr;
        m_bOk = false;
    }
}

/************************************************
 * 功能：解析json是否正常
 * 返回值：
 *      bool：解析结果，true -- 正常，false -- 异常
 * ***********************************************/
bool JsonBean::isJsonOk() const
{
    return m_bOk;
}

/************************************************
 * 功能：读取JSON数据
 * 返回值：
 *      std::string：JSON数据
 * ***********************************************/
std::string JsonBean::data()
{
    if(m_pJson)
    {
        char* pData = cJSON_Print(m_pJson);
        m_strJsonData = std::string(pData);
        free(pData);
    }

    return m_strJsonData;
}

/************************************************
 * 功能：读取对应无格式的JSON数据
 * 返回值：
 *      std::string：无格式JSON数据
 * ***********************************************/
std::string JsonBean::unformattedData()
{
    if(m_pJson)
    {
        char* pData = cJSON_PrintUnformatted(m_pJson);
        m_strJsonData = std::string(pData);
        free(pData);
    }

    return m_strJsonData;
}

/************************************************
 * 功能：返回JSON数组子对象个数
 * 返回值：
 *      int：JSON数组子对象个数
 * ***********************************************/
int JsonBean::count() const
{
    int iCount = 0;
    if(m_pJson)
    {
        iCount = cJSON_GetArraySize(m_pJson);
    }

    return iCount;
}

/************************************************
 * 功能：读取JSON数组子对象
 * 输入参数：
 *      iIndex：JSON数组子对象索引
 * 返回值：
 *      JsonBean：JSON数组子对象
 * ***********************************************/
JsonBean JsonBean::at(int iIndex) const
{
    JsonBean objBean;
    if(m_pJson)
    {
        cJSON* pItem = cJSON_GetArrayItem(m_pJson, iIndex);
        if(pItem)
        {
            cJSON_Delete(objBean.m_pJson);
            objBean.m_pJson = cJSON_Duplicate(pItem, 1);
        }
    }

    return objBean;
}

/************************************************
 * 功能：判断是否是JSON数组类型
 * 返回值：
 *      bool：是否JOSN数组，true -- 是，false -- 否
 * ***********************************************/
bool JsonBean::isArray() const
{
    bool bArray = false;
    if(m_pJson)
    {
        bArray = (m_pJson->type & 0xFF) == cJSON_Array;
    }

    return bArray;
}

/************************************************
 * 功能：读取子JSON对象
 * 输入参数：
 *      strKey：键值
 * 返回值：
 *      JsonBean：对应的子对象
 * ***********************************************/
JsonBean JsonBean::value(const std::string &strKey)
{
    JsonBean objBean;
    if(m_pJson)
    {
        cJSON* pJson = cJSON_GetObjectItem(m_pJson, strKey.c_str());
        if(pJson)
        {
            cJSON_Delete(objBean.m_pJson);
            objBean.m_pJson = cJSON_Duplicate(pJson, 1);
        }
    }

    return objBean;
}

/************************************************
 * 功能：JSON对象是否存在
 * 输入参数：
 *      strKey：键值
 * 返回值：
 *      bool：是否存在，true -- 存在，false -- 不存在
 * ***********************************************/
bool JsonBean::isExist(const std::string &strKey)
{
    bool bRet = false;
    if(m_pJson)
    {
        cJSON* pJson = cJSON_GetObjectItem(m_pJson, strKey.c_str());
        bRet = pJson ? true : false;
    }

    return bRet;
}

/************************************************
 * 功能：添加空数据
 * 输入参数：
 *      strKey：键值
 * ***********************************************/
void JsonBean::addNull(const std::string &strKey)
{
    if(m_pJson)
    {
        cJSON_AddNullToObject(m_pJson, strKey.c_str());
    }

    return;
}

/************************************************
 * 功能：设置空数据
 * 输入参数：
 *      strKey：键值
 * ***********************************************/
void JsonBean::setNull(const std::string &strKey)
{
    if(m_pJson)
    {
        if(cJSON_GetObjectItem(m_pJson, strKey.c_str()))
        {
            cJSON_DeleteItemFromObject(m_pJson, strKey.c_str());
        }

        addNull(strKey);
    }

    return;
}

/************************************************
 * 功能：添加string型键值数据
 * 输入参数：
 *      strKey：键值
 *      pValue：数据
 * ***********************************************/
void JsonBean::add(const std::string &strKey, const char *pValue)
{
    if(m_pJson)
    {
        if(pValue)
        {
            cJSON_AddStringToObject(m_pJson, strKey.c_str(), pValue);
        }
    }

    return;
}

/************************************************
 * 功能：设置string型键值数据
 * 输入参数：
 *      strKey：键值
 *      pValue：数据
 * ***********************************************/
void JsonBean::set(const std::string &strKey, const char *pValue)
{
    if(m_pJson)
    {
        cJSON* pSon = cJSON_GetObjectItem(m_pJson, strKey.c_str());
        if(!pSon)
        {
            add(strKey, pValue);
        }
        else
        {
            if(pValue)
            {
                if(pSon->valuestring)
                {
                    free(pSon->valuestring);
                }

                size_t uiLen = strlen(pValue) + 1;

                pSon->valuestring = static_cast<char*>(malloc(uiLen));
                if(pSon->valuestring)
                {
                    memset(pSon->valuestring, 0, uiLen);
                    memcpy(pSon->valuestring, pValue, uiLen - 1);
                }
            }
        }
    }

    return;
}

/************************************************
 * 功能：添加string型键值数据
 * 输入参数：
 *      strKey：键值
 *      strValue：数据
 * ***********************************************/
void JsonBean::add(const std::string &strKey, const std::string &strValue)
{
    if(m_pJson)
    {
        cJSON_AddStringToObject(m_pJson, strKey.c_str(), strValue.c_str());
    }

    return;
}

/************************************************
 * 功能：设置string型键值数据
 * 输入参数：
 *      strKey：键值
 *      strValue：数据
 * ***********************************************/
void JsonBean::set(const std::string &strKey, const std::string &strValue)
{
    if(m_pJson)
    {
        cJSON* pSon = cJSON_GetObjectItem(m_pJson, strKey.c_str());
        if(!pSon)
        {
            add(strKey, strValue);
        }
        else
        {
            if(pSon->valuestring)
            {
                free(pSon->valuestring);
            }

            size_t uiLen = strlen(strValue.c_str()) + 1;

            pSon->valuestring = static_cast<char*>(malloc(uiLen));
            if(pSon->valuestring)
            {
                memset(pSon->valuestring, 0, uiLen);
                memcpy(pSon->valuestring, strValue.c_str(), uiLen - 1);
            }
        }
    }

    return;
}

/************************************************
 * 功能：添加double型键值数据
 * 输入参数：
 *      strKey：键值
 *      dValue：数据
 * ***********************************************/
void JsonBean::add(const std::string &strKey, const double &dValue)
{
    if(m_pJson)
    {
        cJSON_AddNumberToObject(m_pJson, strKey.c_str(), dValue);
    }

    return;
}

/************************************************
 * 功能：设置double型键值数据
 * 输入参数  ：
 *      strKey：键值
 *      dValue：数据
 * ***********************************************/
void JsonBean::set(const std::string &strKey, const double &dValue)
{
    if(m_pJson)
    {
        cJSON* pSon = cJSON_GetObjectItem(m_pJson, strKey.c_str());
        if(!pSon)
        {
            add(strKey, dValue);
        }
        else
        {
            pSon->valueint = static_cast<int>(dValue);
            pSon->valuedouble = dValue;
        }
    }

    return;
}

/************************************************
 * 功能：添加int型键值数据
 * 输入参数  ：
 *      strKey：键值
 *      iValue：数据
 * ***********************************************/
void JsonBean::add(const std::string &strKey, const int &iValue)
{
    if(m_pJson)
    {
        cJSON_AddNumberToObject(m_pJson, strKey.c_str(), iValue);
    }

    return;
}

/************************************************
 * 功能：设置int型键值数据
 * 输入参数  ：
 *      strKey：键值
 *      iValue：数据
 * ***********************************************/
void JsonBean::set(const std::string &strKey, const int &iValue)
{
    if(m_pJson)
    {
        cJSON* pSon = cJSON_GetObjectItem(m_pJson, strKey.c_str());
        if(!pSon)
        {
            add(strKey, iValue);
        }
        else
        {
            pSon->valueint = iValue;
            pSon->valuedouble = iValue;
        }
    }

    return;
}

/************************************************
 * 功能：添加bool型键值数据
 * 输入参数：
 *      strKey：键值
 *      bValue：数据
 * ***********************************************/
void JsonBean::add(const std::string &strKey, const bool &bValue)
{
    if(m_pJson)
    {
        cJSON_AddBoolToObject(m_pJson, strKey.c_str(), bValue);
    }

    return;
}

/************************************************
 * 功能：设置bool型键值数据
 * 输入参数：
 *      strKey：键值
 *      bValue：数据
 * ***********************************************/
void JsonBean::set(const std::string &strKey, const bool &bValue)
{
    if(m_pJson)
    {
        cJSON* pSon = cJSON_GetObjectItem(m_pJson, strKey.c_str());
        if(!pSon)
        {
            add(strKey, bValue);
        }
        else
        {
            pSon->type = bValue ? cJSON_True : cJSON_False;
        }
    }

    return;
}

/************************************************
 * 功能：添加JSON型键值数据
 * 输入参数  ：
 *      strKey：键值
 *      objValue：数据
 * ***********************************************/
void JsonBean::add(const std::string &strKey, const JsonBean &objValue)
{
    if(m_pJson)
    {
        cJSON* pJson = cJSON_Duplicate(objValue.m_pJson, 1);
        if(pJson)
        {
            cJSON_AddItemToObject(m_pJson, strKey.c_str(), pJson);
        }
    }

    return;
}

/************************************************
 * 功能：设置JSON型键值数据
 * 输入参数  ：
 *      strKey：键值
 *      objValue：数据
 * ***********************************************/
void JsonBean::set(const std::string &strKey, const JsonBean &objValue)
{
    if(m_pJson)
    {
        cJSON* pSon = cJSON_GetObjectItem(m_pJson, strKey.c_str());
        if(pSon)
        {
            cJSON_DeleteItemFromObject(m_pJson, strKey.c_str());
        }

        add(strKey, objValue);
    }

    return;
}

/************************************************
 * 功能：添加子对象数据到当前JSON数组中
 * 输入参数：
 *      objChildValue：子对象
 * ***********************************************/
void JsonBean::addDataToArray(const JsonBean &objChildValue)
{
    if(m_pJson && isArray())
    {
        cJSON* pJson = cJSON_Duplicate(objChildValue.m_pJson, 1);
        if(pJson)
        {
            cJSON_AddItemToArray(m_pJson, pJson);
        }
    }

    return;
}

/************************************************
 * 功能：添加字符串数组到JSON中，例如{"arrVal":["str1", "str2", "str3"]}
 * 输入参数：
 *      pValue：字符串值
 * ***********************************************/
void JsonBean::addDataToArray(const char* pValue)
{
    if(m_pJson && isArray())
    {
        cJSON_AddItemToArray(m_pJson, cJSON_CreateString(pValue));
    }

    return;
}

/************************************************
 * 功能：添加字符串数组到JSON中，例如{"arrVal":["str1", "str2", "str3"]}
 * 输入参数：
 *      strValue：字符串值
 * ***********************************************/
void JsonBean::addDataToArray(const std::string &strValue)
{
    if(m_pJson && isArray())
    {
        cJSON_AddItemToArray(m_pJson, cJSON_CreateString(strValue.c_str()));
    }

    return;
}

/************************************************
 * 功能：添加int数组到JSON中，例如{"intVal":[1, 2, 3]}
 * 输入参数：
 *      iValue：int数据
 * ***********************************************/
void JsonBean::addDataToArray(const int &iValue)
{
    if(m_pJson && isArray())
    {
        cJSON_AddItemToArray(m_pJson, cJSON_CreateNumber(iValue));
    }

    return;
}

/************************************************
 * 功能：添加double数组到JSON中，例如{"doubleVal":[1.2, 2.3, 3.4]}
 * 输入参数：
 *      dValue：double数据
 * ***********************************************/
void JsonBean::addDataToArray(const double &dValue)
{
    if(m_pJson && isArray())
    {
        cJSON_AddItemToArray(m_pJson, cJSON_CreateNumber(dValue));
    }

    return;
}

/************************************************
 * 功能：添加bool数组到JSON中，例如{"boolVal":[true, false, true]}
 * 输入参数：
 *      bValue：bool数据
 * ***********************************************/
void JsonBean::addDataToArray(const bool &bValue)
{
    if(m_pJson && isArray())
    {
        cJSON_AddItemToArray(m_pJson, cJSON_CreateBool(bValue));
    }

    return;
}

/************************************************
 * 功能：删除某对key-value
 * 输入参数：
 *      strKey：待删除的key
 * ***********************************************/
void JsonBean::deleteKey(const std::string &strKey)
{
    if(m_pJson)
    {
        cJSON* pSon = cJSON_GetObjectItem(m_pJson, strKey.c_str());
        if(pSon)
        {
            // 说明存在这个key-value
            //cJSON_Delete(pSon);
            cJSON_DeleteItemFromObject(m_pJson, strKey.c_str());
        }
    }

    return;
}

/************************************************
 * 功能：数据转换为字符串值
 * 返回值：
 *      std::string：转换后的数据
 * ***********************************************/
std::string JsonBean::toString() const
{
    std::string strData = "";

    if(m_pJson)
    {
        if(cJSON_String == (m_pJson->type & 0xFF))
        {
            strData = std::string(m_pJson->valuestring);
        }
    }

    return strData;
}

/************************************************
 * 功能：数据转换为bool
 * 返回值：
 *      bool：转换后的数据
 * ***********************************************/
bool JsonBean::toBool() const
{
    bool bData = false;
    if(m_pJson)
    {
        if(((m_pJson->type & 0xFF) == cJSON_True) || ((m_pJson->type & 0xFF) == cJSON_False))
        {
            bData = ((m_pJson->type & 0xFF) == cJSON_True);
        }
    }

    return bData;
}

/************************************************
 * 功能：数据转换为int
 * 返回值：
 *      int：转换后的数据
 * ***********************************************/
int JsonBean::toInt() const
{
    int iData = 0;
    if(m_pJson)
    {
        if((m_pJson->type & 0xFF) == cJSON_Number)
        {
            //iData = m_pJson->valueint;//not valid in sometime
            iData = static_cast<int>(m_pJson->valuedouble);
        }
    }

    return iData;
}

/************************************************
 * 功能：数据转换为double
 * 返回值：
 *      double：转换后的数据
 * ***********************************************/
double JsonBean::toDouble() const
{
    double dData = 0;
    if(m_pJson)
    {
        if((m_pJson->type & 0xFF) == cJSON_Number)
        {
            dData = m_pJson->valuedouble;
        }
    }

    return dData;
}

/************************************************
 * 功能：根据key获取string数据，包括object、Array等
 * 输入参数：
 *      strKey：key信息
 * 返回值：
 *      std::string：获得的数据
 * ***********************************************/
std::string JsonBean::getString(const std::string& strKey)
{
    std::string strRet = "";

    if(m_pJson) {
        cJSON* pJson = cJSON_GetObjectItem(m_pJson, strKey.c_str());
        if(pJson) {
            if(cJSON_String == (pJson->type & 0xFF)) {
                strRet = std::string(pJson->valuestring);
            } else {
                strRet = std::string(cJSON_PrintUnformatted(pJson));
            }
        }
    }

    return strRet;
}

/************************************************
 * 功能：根据key获取int数据
 * 输入参数：
 *      strKey：key信息
 * 返回值：
 *      int：获得的数据
 * ***********************************************/
int JsonBean::getInt(const std::string& strKey)
{
    int iRet = 0;

    if(m_pJson) {
        cJSON* pJson = cJSON_GetObjectItem(m_pJson, strKey.c_str());
        if(pJson) {
            if(cJSON_Number == (pJson->type & 0xFF)) {
                //iRet = m_pJson->valueint;//not valid in sometime
                iRet = static_cast<int>(pJson->valuedouble);
            }
        }
    }

    return iRet;
}

/************************************************
 * 功能：根据key获取double数据
 * 输入参数：
 *      strKey：key信息
 * 返回值：
 *      double：获得的数据
 * ***********************************************/
double JsonBean::getDouble(const std::string& strKey)
{
    double dRet = 0;

    if(m_pJson) {
        cJSON* pJson = cJSON_GetObjectItem(m_pJson, strKey.c_str());
        if(pJson) {
            if(cJSON_Number == (pJson->type & 0xFF)) {
                dRet = pJson->valuedouble;
            }
        }
    }

    return dRet;
}

/************************************************
 * 功能：根据key获取bool数据
 * 输入参数：
 *      strKey：key信息
 * 返回值：
 *      bool：获得的数据
 * ***********************************************/
bool JsonBean::getBool(const std::string& strKey)
{
    bool bRet = 0;

    if(m_pJson) {
        cJSON* pJson = cJSON_GetObjectItem(m_pJson, strKey.c_str());
        if(pJson) {
            if((cJSON_True == (pJson->type & 0xFF)) || (cJSON_False == (pJson->type & 0xFF))) {
                bRet = ((pJson->type & 0xFF) == cJSON_True);
            }
        }
    }

    return bRet;
}

/************************************************
 * 功能：添加string数组数据，包括object、Array等
 * 输入参数：
 *      vtValues：待添加的数据集合
 *      eType：当待添加的数据为object、Array时，需要填写
 * ***********************************************/
void JsonBean::addArray(const std::vector<std::string> &vtValues, Type eType)
{
    if (m_pJson && isArray()) {
        for (size_t i = 0, size = vtValues.size(); i < size; ++i) {
            if (JsonBean::NA == eType) {
                cJSON_AddItemToArray(m_pJson, cJSON_CreateString(vtValues[i].c_str()));
            } else {
                cJSON *pJson = cJSON_Parse(vtValues[i].c_str());
                if (pJson) {
                    cJSON* json = cJSON_Duplicate(pJson, 1);
                    if(json) {
                        cJSON_AddItemToArray(m_pJson, json);
                    }
                    cJSON_Delete(pJson);
                }
            }
        }
    }

    return;
}

/************************************************
 * 功能：添加int数组数据
 * 输入参数：
 *      vtValues：待添加的数据集合
 * ***********************************************/
void JsonBean::addArray(const std::vector<int> &vtValues)
{
    if (m_pJson && isArray()) {
        for (size_t i = 0, size = vtValues.size(); i < size; ++i) {
            cJSON_AddItemToArray(m_pJson, cJSON_CreateNumber(vtValues[i]));
        }
    }

    return;
}

/************************************************
 * 功能：添加double数组数据
 * 输入参数：
 *      vtValues：待添加的数据集合
 * ***********************************************/
void JsonBean::addArray(const std::vector<double> &vtValues)
{
    if (m_pJson && isArray()) {
        for (size_t i = 0, size = vtValues.size(); i < size; ++i) {
            cJSON_AddItemToArray(m_pJson, cJSON_CreateNumber(vtValues[i]));
        }
    }

    return;
}

/************************************************
 * 功能：添加bool数组数据
 * 输入参数：
 *      vtValues：待添加的数据集合
 * ***********************************************/
void JsonBean::addArray(const std::vector<bool> &vtValues)
{
    if (m_pJson && isArray()) {
        for (size_t i = 0, size = vtValues.size(); i < size; ++i) {
            cJSON_AddItemToArray(m_pJson, cJSON_CreateBool(vtValues[i]));
        }
    }

    return;
}

/************************************************
 * 功能：添加object数组数据
 * 输入参数：
 *      vtValues：待添加的数据集合
 * ***********************************************/
void JsonBean::addArray(const std::vector<JsonBean> &vtValues)
{
    if (m_pJson && isArray()) {
        for (size_t i = 0, size = vtValues.size(); i < size; ++i) {
            cJSON* pJson = cJSON_Duplicate(vtValues[i].m_pJson, 1);
            if(pJson) {
                cJSON_AddItemToArray(m_pJson, pJson);
            }
        }
    }

    return;
}

/************************************************
 * 功能：根据key添加string数组数据，包括object、Array等
 * 输入参数：
 *      strKey：key信息
 *      vtValues：待添加的数据集合
 *      eType：当待添加的数据为object、Array时，需要填写
 * ***********************************************/
void JsonBean::addStringArray(const std::string& strKey, const std::vector<std::string> &vtValues, Type eType)
{
    cJSON *pJson = cJSON_CreateArray();
    if (pJson) {
        for (size_t i = 0, size = vtValues.size(); i < size; ++i) {
            if (JsonBean::NA == eType) {
                cJSON_AddItemToArray(pJson, cJSON_CreateString(vtValues[i].c_str()));
            } else {
                cJSON *pJsonTemp = cJSON_Parse(vtValues[i].c_str());
                if (pJsonTemp) {
                    cJSON* json = cJSON_Duplicate(pJsonTemp, 1);
                    if(json) {
                        cJSON_AddItemToArray(pJson, json);
                    }
                    cJSON_Delete(pJsonTemp);
                }
            }
        }

        if (m_pJson) {
            cJSON_AddItemToObject(m_pJson, strKey.c_str(), pJson);
        }
    }

    return;
}

/************************************************
 * 功能：根据key添加int数组数据
 * 输入参数：
 *      strKey：key信息
 *      vtValues：待添加的数据集合
 * ***********************************************/
void JsonBean::addIntArray(const std::string& strKey, const std::vector<int> &vtValues)
{
    cJSON *pJson = cJSON_CreateArray();
    if (pJson) {
        for (size_t i = 0, size = vtValues.size(); i < size; ++i) {
            cJSON_AddItemToArray(pJson, cJSON_CreateNumber(vtValues[i]));
        }

        if (m_pJson) {
            cJSON_AddItemToObject(m_pJson, strKey.c_str(), pJson);
        }
    }

    return;
}

/************************************************
 * 功能：根据key添加double数组数据
 * 输入参数：
 *      strKey：key信息
 *      vtValues：待添加的数据集合
 * ***********************************************/
void JsonBean::addDoubleArray(const std::string& strKey, const std::vector<double> &vtValues)
{
    cJSON *pJson = cJSON_CreateArray();
    if (pJson) {
        for (size_t i = 0, size = vtValues.size(); i < size; ++i) {
            cJSON_AddItemToArray(pJson, cJSON_CreateNumber(vtValues[i]));
        }

        if (m_pJson) {
            cJSON_AddItemToObject(m_pJson, strKey.c_str(), pJson);
        }
    }

    return;
}

/************************************************
 * 功能：根据key添加bool数组数据
 * 输入参数：
 *      strKey：key信息
 *      vtValues：待添加的数据集合
 * ***********************************************/
void JsonBean::addBoolArray(const std::string& strKey, const std::vector<bool> &vtValues)
{
    cJSON *pJson = cJSON_CreateArray();
    if (pJson) {
        for (size_t i = 0, size = vtValues.size(); i < size; ++i) {
            cJSON_AddItemToArray(pJson, cJSON_CreateBool(vtValues[i]));
        }

        if (m_pJson) {
            cJSON_AddItemToObject(m_pJson, strKey.c_str(), pJson);
        }
    }

    return;
}

/************************************************
 * 功能：根据key添加object数组数据
 * 输入参数：
 *      strKey：key信息
 *      vtValues：待添加的数据集合
 * ***********************************************/
void JsonBean::addObjArray(const std::string& strKey, const std::vector<JsonBean> &vtValues)
{
    cJSON *pJson = cJSON_CreateArray();
    if (pJson) {
        for (size_t i = 0, size = vtValues.size(); i < size; ++i) {
            cJSON* json = cJSON_Duplicate(vtValues[i].m_pJson, 1);
            if(json) {
                cJSON_AddItemToArray(pJson, json);
            }
        }

        if (m_pJson) {
            cJSON_AddItemToObject(m_pJson, strKey.c_str(), pJson);
        }
    }

    return;
}

/************************************************
 * 功能：根据key获取string数组数据，包括object、Array等
 * 输入参数：
 *      strKey：key信息
 * 输出参数：
 *      vtValues：获得的数据集合
 * ***********************************************/
void JsonBean::getStringArray(const std::string& strKey, std::vector<std::string> &vtValues)
{
    if(m_pJson) {
        cJSON* pJson = cJSON_GetObjectItem(m_pJson, strKey.c_str());
        if(pJson) {
            bool bArray = (cJSON_Array == (pJson->type & 0xFF));
            if (bArray) {
                int iCnt = cJSON_GetArraySize(pJson);
                for (int i = 0; i < iCnt; ++i) {
                    cJSON* pItem = cJSON_GetArrayItem(pJson, i);
                    if (pItem) {
                        if(cJSON_String == (pItem->type & 0xFF)) {
                            vtValues.emplace_back(std::string(pItem->valuestring));
                        } else {
                            vtValues.emplace_back(std::string(cJSON_PrintUnformatted(pItem)));
                        }
                    }
                }
            }
        }
    }

    return;
}

/************************************************
 * 功能：根据key获取int数组数据
 * 输入参数：
 *      strKey：key信息
 * 输出参数：
 *      vtValues：获得的数据集合
 * ***********************************************/
void JsonBean::getIntArray(const std::string& strKey, std::vector<int> &vtValues)
{
    if(m_pJson) {
        cJSON* pJson = cJSON_GetObjectItem(m_pJson, strKey.c_str());
        if(pJson) {
            bool bArray = (cJSON_Array == (pJson->type & 0xFF));
            if (bArray) {
                int iCnt = cJSON_GetArraySize(pJson);
                for (int i = 0; i < iCnt; ++i) {
                    cJSON* pItem = cJSON_GetArrayItem(pJson, i);
                    if (pItem) {
                        if(cJSON_Number == (pItem->type & 0xFF)) {
                            vtValues.emplace_back(static_cast<int>(pItem->valuedouble));
                        }
                    }
                }
            }
        }
    }

    return;
}

/************************************************
 * 功能：根据key获取double数组数据
 * 输入参数：
 *      strKey：key信息
 * 输出参数：
 *      vtValues：获得的数据集合
 * ***********************************************/
void JsonBean::getDoubleArray(const std::string& strKey, std::vector<double> &vtValues)
{
    if(m_pJson) {
        cJSON* pJson = cJSON_GetObjectItem(m_pJson, strKey.c_str());
        if(pJson) {
            bool bArray = (cJSON_Array == (pJson->type & 0xFF));
            if (bArray) {
                int iCnt = cJSON_GetArraySize(pJson);
                for (int i = 0; i < iCnt; ++i) {
                    cJSON* pItem = cJSON_GetArrayItem(pJson, i);
                    if (pItem) {
                        if(cJSON_Number == (pItem->type & 0xFF)) {
                            vtValues.emplace_back(pItem->valuedouble);
                        }
                    }
                }
            }
        }
    }

    return;
}

/************************************************
 * 功能：根据key获取bool数组数据
 * 输入参数：
 *      strKey：key信息
 * 输出参数：
 *      vtValues：获得的数据集合
 * ***********************************************/
void JsonBean::getBoolArray(const std::string& strKey, std::vector<bool> &vtValues)
{
    if(m_pJson) {
        cJSON* pJson = cJSON_GetObjectItem(m_pJson, strKey.c_str());
        if(pJson) {
            bool bArray = (cJSON_Array == (pJson->type & 0xFF));
            if (bArray) {
                int iCnt = cJSON_GetArraySize(pJson);
                for (int i = 0; i < iCnt; ++i) {
                    cJSON* pItem = cJSON_GetArrayItem(pJson, i);
                    if (pItem) {
                        if((cJSON_True == (pItem->type & 0xFF)) || (cJSON_False == (pItem->type & 0xFF))) {
                            bool bRet = ((pItem->type & 0xFF) == cJSON_True);
                            vtValues.emplace_back(bRet);
                        }
                    }
                }
            }
        }
    }

    return;
}

/************************************************
 * 功能：根据key获取object数组数据
 * 输入参数：
 *      strKey：key信息
 * 输出参数：
 *      vtValues：获得的数据集合
 * ***********************************************/
void JsonBean::getObjArray(const std::string& strKey, std::vector<JsonBean> &vtValues)
{
    if(m_pJson) {
        cJSON* pJson = cJSON_GetObjectItem(m_pJson, strKey.c_str());
        if(pJson) {
            bool bArray = (cJSON_Array == (pJson->type & 0xFF));
            if (bArray) {
                int iCnt = cJSON_GetArraySize(pJson);
                for (int i = 0; i < iCnt; ++i) {
                    cJSON* pItem = cJSON_GetArrayItem(pJson, i);
                    if (pItem) {
                        JsonBean obj;
                        obj.m_bOk = true;
                        obj.m_pJson = cJSON_Duplicate(pItem, 1);
                        obj.m_strJsonData = std::string(cJSON_PrintUnformatted(pItem));
                        vtValues.emplace_back(obj);
                    }
                }
            }
        }
    }

    return;
}

